package com.eduagent.xwqeduagent.service.lmpl;

import com.eduagent.xwqeduagent.adviser.MyLoggerAdvisor;
import com.eduagent.xwqeduagent.model.vo.OJProgrammingAssistantVO;
import com.eduagent.xwqeduagent.service.OJProgrammingAssistantService;
import com.eduagent.xwqeduagent.utils.oj.JudgeService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.ai.chat.model.ChatResponse;
import org.springframework.ai.chat.client.advisor.AbstractChatMemoryAdvisor;
import org.springframework.stereotype.Service;

import jakarta.annotation.Resource;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static org.springframework.ai.chat.client.advisor.AbstractChatMemoryAdvisor.CHAT_MEMORY_CONVERSATION_ID_KEY;
import static org.springframework.ai.chat.client.advisor.AbstractChatMemoryAdvisor.CHAT_MEMORY_RETRIEVE_SIZE_KEY;

/**
 * OJ编程助手服务实现
 */
@Slf4j
@Service
public class OJProgrammingAssistantServiceImpl implements OJProgrammingAssistantService {

    private final ChatClient chatClient;
    
    @Resource
    private JudgeService judgeService;
    
    /**
     * 系统提示词
     */
    private final String systemPrompt = 
            "你是一个专业的编程助手，帮助学生理解和解决算法题目。" + 
            "你的任务是根据学生提供的题目描述、当前代码和具体问题，给出专业、详细的解答。" + 
            "请严格按照以下格式提供你的回答，使用明确的分隔符以便于结构化处理：\n\n" +
            
            "## 解答\n" +
            "[在这里提供对问题的基本回答，解释你理解的问题，以及总体思路]\n\n" +
            
            "## 代码分析与优化建议\n" +
            "[详细分析当前代码的问题和可以改进的地方]\n\n" +
            
            "## 解决方案代码\n" +
            "```\n" +
            "[提供优化后的代码，如果有必要的话]\n" +
            "```\n\n" +
            
            "## 复杂度分析\n" +
            "[分析算法的时间复杂度和空间复杂度，解释原因]\n\n" +
            
            "请遵循以下指导原则：\n" +
            "1. 分析问题：理解题目要求和学生的具体疑问\n" + 
            "2. 代码分析：找出当前代码中存在的问题或可以改进的地方\n" + 
            "3. 算法思路：提供清晰的解题思路和算法说明\n" + 
            "4. 代码优化：如有必要，提供更优化的代码实现\n" + 
            "5. 时间复杂度和空间复杂度分析：解释算法效率\n\n" + 
            
            "回答应当专业、有条理，但同时易于理解。" +
            "请确保你的回答包含所有四个部分，并严格使用规定的分隔符（## 解答、## 代码分析与优化建议、## 解决方案代码、## 复杂度分析），这对于正确处理你的输出非常重要。";

    public OJProgrammingAssistantServiceImpl(ChatModel dashscopeChatModel) {
        this.chatClient = ChatClient.builder(dashscopeChatModel)
                .defaultSystem(systemPrompt)
                .defaultAdvisors(new MyLoggerAdvisor())
                .build();
    }

    @Override
    public OJProgrammingAssistantVO provideAssistance(
            String problemDetails, 
            String userCode, 
            String userQuestion, 
            String language,
            String sessionId) {
        
        log.info("收到OJ编程助手请求: 问题: {}, 语言: {}", userQuestion, language);
        
        // 构建用户查询
        String userPrompt = formatUserPrompt(problemDetails, userCode, userQuestion, language);
        
        // 调用AI获取回答
        ChatResponse chatResponse = chatClient
                .prompt()
                .system(systemPrompt)
                .user(userPrompt)
                .advisors(spec -> spec.param(CHAT_MEMORY_CONVERSATION_ID_KEY, sessionId)
                        .param(CHAT_MEMORY_RETRIEVE_SIZE_KEY, 20))
                .advisors(new MyLoggerAdvisor())
                .call()
                .chatResponse();
        
        String answer = chatResponse.getResult().getOutput().getText();
        log.info("OJ编程助手回答已生成，长度: {}", answer.length());
        
        // 解析AI回答，提取出各部分内容
        OJProgrammingAssistantVO result = parseAIResponse(answer, userQuestion);
        return result;
    }
    
    /**
     * 格式化发送给AI的用户提问
     */
    private String formatUserPrompt(String problemDetails, String userCode, String userQuestion, String language) {
        return String.format(
                "【题目描述】\n%s\n\n" +
                "【我的代码】(使用%s语言)\n%s\n\n" +
                "【我的问题】\n%s",
                problemDetails, language, userCode, userQuestion);
    }
    
    /**
     * 解析AI回答，提取不同部分内容
     */
    private OJProgrammingAssistantVO parseAIResponse(String aiResponse, String userQuestion) {
        OJProgrammingAssistantVO result = new OJProgrammingAssistantVO();
        result.setUserQuestion(userQuestion);
        
        // 使用正则表达式提取各部分内容
        // 解答部分
        String answer = extractSection(aiResponse, "## 解答", "## 代码分析与优化建议");
        result.setAnswer(answer != null ? answer.trim() : aiResponse);
        
        // 代码分析与优化建议
        String codeImprovement = extractSection(aiResponse, "## 代码分析与优化建议", "## 解决方案代码");
        result.setCodeImprovement(codeImprovement != null ? codeImprovement.trim() : "");
        
        // 解决方案代码
        String solutionCode = extractSection(aiResponse, "## 解决方案代码", "## 复杂度分析");
        if (solutionCode != null) {
            // 移除代码块标记```
            solutionCode = solutionCode.trim().replaceAll("```[a-zA-Z]*\\n|```", "").trim();
            result.setSolutionCode(solutionCode);
        }
        
        // 复杂度分析
        String complexityAnalysis = extractSection(aiResponse, "## 复杂度分析", null);
        result.setComplexityAnalysis(complexityAnalysis != null ? complexityAnalysis.trim() : "");
        
        return result;
    }
    
    /**
     * 从文本中提取指定开始和结束标记之间的内容
     */
    private String extractSection(String text, String startMarker, String endMarker) {
        int startIndex = text.indexOf(startMarker);
        if (startIndex == -1) return null;
        
        startIndex += startMarker.length();
        int endIndex = endMarker != null ? text.indexOf(endMarker, startIndex) : text.length();
        if (endIndex == -1) endIndex = text.length();
        
        return text.substring(startIndex, endIndex);
    }
} 